package cn.gjxblog.robot;

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.event.InputEvent;
import java.awt.image.BufferedImage;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @Author guojiaxun
 * @Date 2019/9/26 10:17
 */
public class RobotPlus extends Robot {
    /**
     * 当前屏幕的宽度。
     */
    public static int screenWidth;
    /**
     * 当前屏幕的高度。
     */
    public static int screenHeight;

    /**
     * 图片搜索的缓存，搜索图片时某个图片使用后会将其加入内存，以后再次使用此图会先从程序内存找，内存没有才会从硬盘加载。
     */
    public static Map<String, BufferedImage> bufferedImageList;

    static {
        bufferedImageList = new HashMap<String, BufferedImage>();
        screenWidth = (int)Toolkit.getDefaultToolkit().getScreenSize().getWidth();
        screenHeight = (int)Toolkit.getDefaultToolkit().getScreenSize().getHeight();
    }


    public RobotPlus() throws AWTException {
    }

    public RobotPlus(GraphicsDevice screen) throws AWTException {
        super(screen);
    }

    /**
     * 当前屏幕上鼠标左键点击
     */
    public void mouseLeftClick(int x,int y){
        mouseClick(x, y, InputEvent.BUTTON1_MASK);
    }

    /**
     * 当前屏幕上鼠标右键点击
     */
    public void mouseRightClick(int x,int y){
        mouseClick(x, y, InputEvent.BUTTON3_MASK);
    }


    /**
     * 当前屏幕指定区域，与指定的图片比较其相似度
     */
    public CoordBean imageSearch(String imageName){
        BufferedImage cutImage = createScreenCapture(new Rectangle(0, 0, screenWidth, screenHeight));
        return imageSearch(cutImage, getResourceImage(imageName), 31);
    }


    public CoordBean imageSearch(BufferedImage sourceImage,BufferedImage searchImage,int sim){
        List<CoordBean> list = new ArrayList<>();

        RgbImageComparerBean pxSource = ImageUtils.getPX(sourceImage);
        RgbImageComparerBean pxSearch = ImageUtils.getPX(searchImage);

        int[][] px = pxSource.getColorArray();	//原图的像素点
        int[][] pxS = pxSearch.getColorArray();	//要搜索的目标图的像素点
        int pxSXMax = pxSearch.getImgWidth()-1;	//要搜索的图的像素点的数组最大x下标
        int pxSYMax = pxSearch.getImgHeight()-1;	//要搜索的图的像素点的数组最大y下标
        int xSearchEnd = pxSource.getImgWidth()-pxSearch.getImgWidth();	//可搜索的x坐标的原图像素数组下标+1
        int ySearchEnd = pxSource.getImgHeight()-pxSearch.getImgHeight();	//可搜索的y坐标的原图像素数组下标+1
        //要搜索的图片的纵横中心点的像素大小，非坐标
        int contentSearchX = 1;
        int contentSearchY = 1;

        //根据sim计算最小像素匹配率
        double pxPercent = 0.99f;
        if(sim>0){
            //RGB的模糊率／4为最小的像素匹配率，大于这个匹配率，为图像识别成功
            pxPercent = ((double)sim/255)/4;
        }


        for (int x = 0; x < xSearchEnd; x++) {
            for (int y = 0; y < ySearchEnd; y++) {
                // 对比，是否通过
                boolean contrast = false;

                //如果使用的精确搜索（SIM_ACCURATE、SIM_ACCURATE_VERY），则匹配图像的四个角的点跟中心点
                if (sim < 32) {
                    //首先比较图片四个角的四个点，如果四个点比较通过，则进行下一轮比较

                    //要搜索的图左上坐标在原图匹配成功
                    if (!ImageUtils.colorCompare(px[x][y], pxS[0][0], sim)) {
                        continue;
                    }
                    // 原图要搜索的，定位搜索图右上坐标x下标
                    int pxX = x + pxSearch.getImgWidth() - 1;
                    //要搜索的图右上坐标在原图匹配成功
                    if (!ImageUtils.colorCompare(px[pxX][y], pxS[pxSXMax][0], sim)) {
                         continue;
                    }
                    //原图要搜索的，定位搜索图右上坐标x下标
                    int pxY = y + pxSearch.getImgHeight() - 1;
                    //要搜索的图左下坐标在原图匹配成功
                    if (!ImageUtils.colorCompare(px[x][pxY], pxS[0][pxSYMax], sim)) {
                        continue;

                     }
                     // 要搜索的图右下坐标在原图匹配成功
                    if (!ImageUtils.colorCompare(px[pxX][pxY], pxS[pxSXMax][pxSYMax], sim)) {
                        continue;
                    }

                    //中心点匹配
                    if (pxSXMax > 2) {
                        contentSearchX = (int) Math.ceil(pxSXMax / 2);
                    }
                    if (pxSYMax > 2) {
                        contentSearchY = (int) Math.ceil(pxSYMax / 2);
                    }
                    //要搜索的图的中心点坐标在原图上匹配成功
                    if (ImageUtils.colorCompare(px[x + contentSearchX][y + contentSearchY], pxS[contentSearchX][contentSearchY], sim)) {

                        contrast = true;
                    }
                }

                //模糊搜索的大模糊不进行纵横十字搜索
                if(sim < 62){
                    //如果图片四角点对比通过，进而进行要搜索的图片的纵横中心点，十字形像素条的比较之横向像素条比较
                    if(contrast){
                        int yes = 0;
                        //计算以搜索图纵向中心，X横向像素条
                        int ySour = y+contentSearchY;
                        for (int i = 0; i < pxSearch.getImgWidth(); i++) {
                            if(ImageUtils.colorCompare(px[x+i][ySour], pxS[i][contentSearchY], sim)){
                                yes++;
                            }
                        }
                        if((yes/pxSearch.getImgWidth() )> pxPercent){
                            contrast = true;
                        }else{
                            continue;
                        }
                    }

                    //如果以上对比通过，进而进行要搜索的图片的纵横中心点，十字形像素条的比较之纵向像素条比较
                    if(contrast){
                        int yes = 0;
                        //计算以搜索图横向为中心，Y纵向像素条
                        int xSour = x+contentSearchX;
                        for (int i = 0; i < pxSearch.getImgHeight(); i++) {
                            if(ImageUtils.colorCompare(px[xSour][y+i], pxS[contentSearchX][i], sim)){
                                yes++;
                            }
                        }
                        if((yes/pxSearch.getImgHeight())>pxPercent){
                            contrast = true;
                        }else{
                            continue;
                        }
                    }
                }else{
                    //大模糊搜索不进行纵横十字搜索
                    contrast = true;
                }

                //进行整个目标图片的像素扫描
                if(contrast){
                    int yes = 0;
                    for (int xS = 0; xS < pxSearch.getImgWidth(); xS++) {
                        for (int yS = 0; yS < pxSearch.getImgHeight(); yS++) {
                            if(ImageUtils.colorCompare(px[x+xS][y+yS], pxS[xS][yS], sim)){
                                yes++;
                            }
                        }
                    }
                    if((yes/pxSearch.getPxCount())> pxPercent){
                        CoordBean coord = new CoordBean();
                        coord.setX(x);
                        coord.setY(y);
                        return coord;
                    }
                }
            }
        }

        return null;
    }

    public void mouseClick(int x, int y, int buttons){
        mouseMove(x, y);
        delay(20);
        mousePress(buttons);
        delay(20);
        mouseRelease(buttons);
    }

    public BufferedImage getResourceImage(String fileName){
        BufferedImage localImg = bufferedImageList.get(fileName);
        if(localImg != null){
            return localImg;
        }

        FileInputStream inputStream = null;
        try {
            inputStream = new FileInputStream(fileName);
            localImg = ImageIO.read(inputStream);
            bufferedImageList.put(fileName, localImg);
            return localImg;
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                inputStream.close();
            } catch (IOException e) {

            }
        }
        return localImg;

    }

}
